import axios from 'axios';
import jwt_decode, { JwtPayload } from 'jwt-decode';

// 创建一个 Axios 实例
const api = axios.create({
    baseURL: 'http://127.0.0.1:3000/zt', // 替换为你的后端 API 基础 URL
    timeout: 10000 // 请求超时时间
});

// 定义 JWT 解码后的类型
interface DecodedToken extends JwtPayload {
    exp: number; // 明确 exp 属性为 number 类型
}

// 定义不需要拦截的请求路径
const skipInterceptPaths = ['/sendVerificationCode','/loginByPhone','/login','/gitee/auth','/register']; // 假设发送验证码的接口路径是 /send-verification-code

// 请求拦截器
api.interceptors.request.use(
    async (config) => {
        // 检查当前请求路径是否需要跳过拦截
        if (skipInterceptPaths.some(path => config.url?.includes(path))) {
            return config;
        }

        // 从本地存储获取 token 和 refreshToken
        const token = localStorage.getItem('token');
        const refreshToken = localStorage.getItem('refreshToken');

        if (token) {
            try {
                // 解码 token 获取过期时间
                const decoded = jwt_decode<DecodedToken>(token);
                const currentTime = Date.now() / 1000;
                console.log(decoded);

                // 检查 token 是否过期
                if (decoded.exp < currentTime && refreshToken) {
                    // 检查 refreshToken 是否过期
                    const refreshDecoded = jwt_decode<DecodedToken>(refreshToken);
                    if (refreshDecoded.exp < currentTime) {
                        // refreshToken 过期，跳转到登录页面或进行其他处理
                        alert('refreshToken 过期，请重新登录');
                        // 这里可以添加跳转到登录页的逻辑，例如：
                        // window.location.href = '/login'; 
                    }

                    // token 过期，使用 refreshToken 刷新 token
                    
                    
                    const refreshResponse = await api.post('/refresh-token', { refreshToken });
                    const newToken = refreshResponse.data.token;
                    const newRefreshToken = refreshResponse.data.refreshToken;

                    // 更新本地存储的 token 和 refreshToken
                    localStorage.setItem('token', newToken);
                    localStorage.setItem('refreshToken', newRefreshToken);

                    // 更新请求头中的 token
                    config.headers.Authorization = `Bearer ${newToken}`;


                } else {
                    // token 未过期，正常添加到请求头
                    config.headers.Authorization = `Bearer ${token}`;
                }
            } catch (error) {
                // 解码或刷新 token 出错，正常添加原 token 到请求头
                config.headers.Authorization = `Bearer ${token}`;
            }
        }

        return config;
    },
    (error) => {
        // 处理请求错误
        console.log('请求发生错误');
        return Promise.reject(error);
    }
);

// 响应拦截器
api.interceptors.response.use(
    (response) => {
        // 检查当前请求路径是否需要跳过拦截
        if (skipInterceptPaths.some(path => response.config.url?.includes(path))) {
            return response;
        }

        // 处理响应数据
        console.log(response);
        // 处理 token
        const newToken = response.data.token;
        if (newToken) {
            // 如果有新 token，则更新本地存储
            localStorage.setItem('token', newToken);
        }
        // 处理刷新令牌
        const newRefreshToken = response.data.refreshToken;
        if (newRefreshToken) {
            // 如果有新刷新令牌，则更新本地存储
            localStorage.setItem('refreshToken', newRefreshToken);
        }

        return response;
    },
    async (error) => {
        const originalRequest = error.config;
        // 检查当前请求路径是否需要跳过拦截
        if (skipInterceptPaths.some(path => originalRequest.url?.includes(path))) {
            return Promise.reject(error);
        }

        if (error.response && error.response.status === 401 && error.response.data.code === 'TOKEN_EXPIRED') {
            // token 过期，尝试使用 refreshToken 刷新
            const refreshToken = localStorage.getItem('refreshToken');
            if (refreshToken) {
                try {
                    const refreshResponse = await api.post('/refresh-token', { refreshToken });
                    const newToken = refreshResponse.data.token;
                    const newRefreshToken = refreshResponse.data.refreshToken;

                    // 更新本地存储的 token 和 refreshToken
                    localStorage.setItem('token', newToken);
                    localStorage.setItem('refreshToken', newRefreshToken);

                    // 更新原请求头中的 token
                    originalRequest.headers.Authorization = `Bearer ${newToken}`;

                    // 重新发起原请求
                    return api(originalRequest);
                } catch (refreshError) {
                    // 刷新 token 失败，跳转到登录页面或进行其他处理
                    alert('刷新 token 失败，请重新登录');
                    // 这里可以添加跳转到登录页的逻辑，例如：
                    // window.location.href = '/login';
                }
            } else {
                // 没有 refreshToken，跳转到登录页面或进行其他处理
                alert('没有 refreshToken，请重新登录');
                // 这里可以添加跳转到登录页的逻辑，例如：
                // window.location.href = '/login';
            }
        }
        // 处理其他响应错误
        if (error.response) {
            // 根据不同的状态码进行不同的处理
            switch (error.response.status) {
                case 401:
                    alert('账号或密码错误');
                    break;
                case 402:
                    alert('密码错误');
                    break;
                default:
                    alert('请求发生错误');
            }
        }
        return Promise.reject(error);
    }
);

export default api;